runtime.stack.lo (field)

133 uses

	runtime (current package)
		cgo_sigaction.go#L58: 		case sp < g.stack.lo || sp >= g.stack.hi:
		cgocall.go#L253: 	inBound := sp > g0.stack.lo && sp <= g0.stack.hi
		cgocall.go#L282: 	g0.stack.lo = sp - 32*1024
		cgocall.go#L301: 			g0.stack.lo = bounds[0]
		cgocall.go#L306: 	g0.stackguard0 = g0.stack.lo + stackGuard
		cgocall.go#L389: 	gp.m.g0.stackguard0 = oldStack.lo + stackGuard
		checkptr.go#L91: 	if gp := getg(); gp.stack.lo <= uintptr(p) && uintptr(p) < gp.stack.hi {
		debugcall.go#L38: 	if sp := sys.GetCallerSP(); !(getg().stack.lo < sp && sp <= getg().stack.hi) {
		malloc.go#L1954: 	if mp.curg.stack.lo <= uintptr(ptr) && uintptr(ptr) < mp.curg.stack.hi {
		mbitmap.go#L1946: 	if gp := getg(); gp.m.curg.stack.lo <= uintptr(p) && uintptr(p) < gp.m.curg.stack.hi {
		mcleanup.go#L816: 	racefree(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		mcleanup.go#L818: 	racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		mcleanup.go#L833: 	racefree(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		mcleanup.go#L835: 	racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		mgc.go#L2317: 	if gp.stack.lo <= p2 && p2 < gp.stack.hi {
		mgcmark.go#L374: 		gp.stack.lo = 0
		mgcmark.go#L960: 		print("scanning async preempted goroutine ", gp.goid, " stack [", hex(gp.stack.lo), ",", hex(gp.stack.hi), ")\n")
		mgcmark.go#L1026: 			print("  live stkobj at", hex(state.stack.lo+uintptr(obj.off)), "of size", obj.size)
		mgcmark.go#L1034: 		b := state.stack.lo + uintptr(obj.off)
		mgcmark.go#L1053: 				println("  dead stkobj at", hex(gp.stack.lo+uintptr(obj.off)), "of size", obj.r.size)
		mgcmark.go#L1498: 					if stk != nil && p >= stk.stack.lo && p < stk.stack.hi {
		mgcmark.go#L1537: 			if state != nil && state.stack.lo <= val && val < state.stack.hi {
		mgcmark.go#L1582: 		if state != nil && state.stack.lo <= val && val < state.stack.hi {
		mgcstack.go#L203: 	if p < s.stack.lo || p >= s.stack.hi {
		mgcstack.go#L279: 	if x.nobj > 0 && uint32(addr-s.stack.lo) < x.obj[x.nobj-1].off+x.obj[x.nobj-1].size {
		mgcstack.go#L292: 	obj.off = uint32(addr - s.stack.lo)
		mgcstack.go#L332: 	off := uint32(a - s.stack.lo)
		panic.go#L1388: 	if sp != 0 && (sp < gp.stack.lo || gp.stack.hi < sp) {
		panic.go#L1389: 		print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
		preempt.go#L177: 			gp.stackguard0 = gp.stack.lo + stackGuard
		preempt.go#L406: 	if sp < gp.stack.lo || sp-gp.stack.lo < asyncPreemptStack {
		proc.go#L598: 		print("runtime: morestack on g0, stack [", hex(g.stack.lo), " ", hex(g.stack.hi), "], sp=", hex(g.sched.sp), ", called from\n")
		proc.go#L904: 	gcrash.stackguard0 = gcrash.stack.lo + 1000
		proc.go#L905: 	gcrash.stackguard1 = gcrash.stack.lo + 1000
		proc.go#L1020: 		mp.gsignal.stackguard1 = mp.gsignal.stack.lo + stackGuard
		proc.go#L1865: 	osStack := gp.stack.lo == 0
		proc.go#L1880: 		gp.stack.lo = gp.stack.hi - size + 1024
		proc.go#L1884: 	gp.stackguard0 = gp.stack.lo + stackGuard
		proc.go#L2661: 	g0.stack.lo = 0
		proc.go#L3348: 	gp.stackguard0 = gp.stack.lo + stackGuard
		proc.go#L4495: 		memclrNoHeapPointers(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L4508: 	gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
		proc.go#L4658: 	if gp.syscallsp < gp.stack.lo || gp.stack.hi < gp.syscallsp {
		proc.go#L4660: 			print("entersyscall inconsistent sp ", hex(gp.syscallsp), " [", hex(gp.stack.lo), ",", hex(gp.stack.hi), "]\n")
		proc.go#L4664: 	if gp.syscallbp != 0 && gp.syscallbp < gp.stack.lo || gp.stack.hi < gp.syscallbp {
		proc.go#L4666: 			print("entersyscall inconsistent bp ", hex(gp.syscallbp), " [", hex(gp.stack.lo), ",", hex(gp.stack.hi), "]\n")
		proc.go#L4810: 	if gp.syscallsp < gp.stack.lo || gp.stack.hi < gp.syscallsp {
		proc.go#L4815: 			print("entersyscallblock inconsistent sp ", hex(sp1), " ", hex(sp2), " ", hex(sp3), " [", hex(gp.stack.lo), ",", hex(gp.stack.hi), "]\n")
		proc.go#L4839: 	if gp.syscallsp < gp.stack.lo || gp.stack.hi < gp.syscallsp {
		proc.go#L4841: 			print("entersyscallblock inconsistent sp ", hex(sp), " ", hex(gp.sched.sp), " ", hex(gp.syscallsp), " [", hex(gp.stack.lo), ",", hex(gp.stack.hi), "]\n")
		proc.go#L4845: 	if gp.syscallbp != 0 && gp.syscallbp < gp.stack.lo || gp.stack.hi < gp.syscallbp {
		proc.go#L4847: 			print("entersyscallblock inconsistent bp ", hex(bp), " ", hex(gp.sched.bp), " ", hex(gp.syscallbp), " [", hex(gp.stack.lo), ",", hex(gp.stack.hi), "]\n")
		proc.go#L5000: 			gp.stackguard0 = gp.stack.lo + stackGuard
		proc.go#L5198: 	gp.stackguard0 = gp.stack.lo + stackGuard
		proc.go#L5280: 				newg.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(newg.stack.lo), unsafe.Pointer(newg.stack.hi))
		proc.go#L5283: 		newg.stackguard0 = newg.stack.lo + stackGuard
		proc.go#L5287: 		*(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
		proc.go#L5380: 	gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
		proc.go#L5470: 	stksize := gp.stack.hi - gp.stack.lo
		proc.go#L5475: 		gp.stack.lo = 0
		proc.go#L5492: 			if gp.stack.lo == 0 {
		proc.go#L5530: 	if gp.stack.lo != 0 && gp.stack.hi-gp.stack.lo != uintptr(startingStackSize) {
		proc.go#L5536: 			gp.stack.lo = 0
		proc.go#L5545: 	if gp.stack.lo == 0 {
		proc.go#L5550: 				gp.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(gp.stack.lo), unsafe.Pointer(gp.stack.hi))
		proc.go#L5553: 		gp.stackguard0 = gp.stack.lo + stackGuard
		proc.go#L5556: 			racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5559: 			msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5562: 			asanunpoison(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
		proc.go#L5576: 		if gp.stack.lo == 0 {
		runtime2.go#L463: 	lo uintptr
		secret.go#L38: 	lo := getg().stack.lo
		secret.go#L93: 	return gp.stack.lo, gp.stack.hi
		signal_unix.go#L563: 	if sp >= mp.gsignal.stack.lo && sp < mp.gsignal.stack.hi {
		signal_unix.go#L575: 	if sp >= mp.g0.stack.lo && sp < mp.g0.stack.hi {
		signal_unix.go#L586: 		st := stackt{ss_size: mp.g0.stack.hi - mp.g0.stack.lo}
		signal_unix.go#L587: 		setSignalstackSP(&st, mp.g0.stack.lo)
		signal_unix.go#L1120: 	print("mp.gsignal stack [", hex(mp.gsignal.stack.lo), " ", hex(mp.gsignal.stack.hi), "], ")
		signal_unix.go#L1121: 	print("mp.g0 stack [", hex(mp.g0.stack.lo), " ", hex(mp.g0.stack.hi), "], sp=", hex(sp), "\n")
		signal_unix.go#L1432: 	gp.m.gsignal.stack.lo = stsp
		signal_unix.go#L1455: 	st := stackt{ss_size: s.hi - s.lo}
		signal_unix.go#L1456: 	setSignalstackSP(&st, s.lo)
		slice.go#L306: 		if gp := getg(); uintptr(oldPtr) < gp.stack.lo || gp.stack.hi <= uintptr(oldPtr) {
		stack.go#L465: 	v := unsafe.Pointer(stk.lo)
		stack.go#L466: 	n := stk.hi - stk.lo
		stack.go#L470: 	if stk.lo+n < stk.hi {
		stack.go#L626: 	if adjinfo.old.lo <= p && p < adjinfo.old.hi {
		stack.go#L653: 	minp := adjinfo.old.lo
		stack.go#L720: 			if bp != 0 && (bp < adjinfo.old.lo || bp >= adjinfo.old.hi) {
		stack.go#L722: 				print("bp=", hex(bp), " min=", hex(adjinfo.old.lo), " max=", hex(adjinfo.old.hi), "\n")
		stack.go#L783: 		if bp != 0 && (bp < adjinfo.old.lo || bp >= adjinfo.old.hi) {
		stack.go#L785: 			print("bp=", hex(bp), " min=", hex(adjinfo.old.lo), " max=", hex(adjinfo.old.hi), "\n")
		stack.go#L830: 	for p := stk.lo; p < stk.hi; p++ {
		stack.go#L839: 		if stk.lo <= p && p < stk.hi && p > sghi {
		stack.go#L905: 	if old.lo == 0 {
		stack.go#L913: 	gcController.addScannableStack(getg().m.p.ptr(), int64(newsize)-int64(old.hi-old.lo))
		stack.go#L921: 		print("copystack gp=", gp, " [", hex(old.lo), " ", hex(old.hi-used), " ", hex(old.hi), "]", " -> [", hex(new.lo), " ", hex(new.hi-used), " ", hex(new.hi), "]/", newsize, "\n")
		stack.go#L932: 		if newsize < old.hi-old.lo && gp.parkingOnChan.Load() {
		stack.go#L970: 	gp.stackguard0 = new.lo + stackGuard // NOTE: might clobber a preempt request
		stack.go#L982: 			gp.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(new.lo), unsafe.Pointer(new.hi))
		stack.go#L984: 			valgrindChangeStack(gp.valgrindStackID, unsafe.Pointer(new.lo), unsafe.Pointer(new.hi))
		stack.go#L995: 		memclrNoHeapPointers(unsafe.Pointer(old.lo), old.hi-old.lo)
		stack.go#L1061: 			" sp=", hex(gp.sched.sp), " stack=[", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n",
		stack.go#L1098: 			gp.stackguard0 = gp.stack.lo + stackGuard
		stack.go#L1103: 	if gp.stack.lo == 0 {
		stack.go#L1111: 	if stackDebug >= 1 || sp < gp.stack.lo {
		stack.go#L1112: 		print("runtime: newstack sp=", hex(sp), " stack=[", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n",
		stack.go#L1116: 	if sp < gp.stack.lo {
		stack.go#L1118: 		print("runtime: split stack overflow: ", hex(sp), " < ", hex(gp.stack.lo), "\n")
		stack.go#L1149: 	oldsize := gp.stack.hi - gp.stack.lo
		stack.go#L1177: 		print("runtime: sp=", hex(sp), " stack=[", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
		stack.go#L1258: 	if gp.stack.lo == 0 {
		stack.go#L1284: 	oldsize := gp.stack.hi - gp.stack.lo
		stack.go#L1296: 	avail := gp.stack.hi - gp.stack.lo
		string.go#L181: 	return stk.lo <= ptr && ptr < stk.hi
		traceallocfree.go#L80: 		trace.GoroutineStackExists(gp.stack.lo, gp.stack.hi-gp.stack.lo)
		traceback.go#L566: 		print("\tstack=[", hex(gp.stack.lo), "-", hex(gp.stack.hi), "\n")
		traceback.go#L1374: 	if lo < stk.lo {
		traceback.go#L1375: 		lo = stk.lo
		traceback.go#L1382: 	print("stack: frame={sp:", hex(frame.sp), ", fp:", hex(frame.fp), "} stack=[", hex(stk.lo), ",", hex(stk.hi), ")\n")